0%

py
py
  • 数据类型
    • 字符串
      • 字符编码:
      • 操作符
        • ch1+ch2生成字符串 "ch1ch2"
      • 方法
        • 截去头尾:str.strip([char])
          • 从str的头尾移除[char]中包含的字符,str本身不变 返回截取后的子串
          • [char]参数缺省表示截去空字符
      • 非转义前缀:s=r"stri\ng" 不识别转义。 所以r"stri\ng"="stri\\ng"
    • 列表和元组
      • 列表 list
        • 定义并初始化:A[ , ]
          • 方括号括起来,逗号隔开
          • 元素构成:任何类型 包括list本身。故可有二维组A[i][j]。
        • 访问:类数组:A[i]
          • num可为负:name[-1]是最后一个 [-2]是倒数第二个。
        • 操作函数:
          • 元素数:len(A) 返回元素数。
          • 追加:A.append(α) 追加元素α于A的末尾。
          • 插入:A.insert(i,α) 插入α到A[i]处。
          • 删除:A.pop(num) 删除A[i]处的元素。 i缺省表示删除末尾元素。
          • 替换:直接赋值
      • 元组 tuple
        • 定义并初始化:A( , )
          • 圆括号括起来,逗号隔开
          • 元素构成:任何,包括列表和元组。
        • 与list区别:元素不可变
        • 歧义:t=(1)
          • t未定义成有一个元素的元组,而是定义为整数1。
          • 定义成元组:t(1,)
    • 集合和字典
      • 集合set
        • 意义:等同于数学集合:无序,互斥
        • 定义
          • 【S={a,b,c}】直接指定集合元素
          • 【 S=set(A) 】定义集合S其内容为列表或元组A中无重的部分
        • 操作函数:
          • 添加: 【S. add(key) 】将key元素添加到集合S中
          • 删除: 【S.remove(key)】将key元素从S中删去
          • etc.
        • 数学运算:
          • 取交 &
          • 取并 |
      • 字典dict
        • 意义: 表示满射map
        • 初始化
          • 大括号:【d={"bob":98 , "tom" : 82} 】直接给出映射关系,定义域和值域
          • dict()
            • d=dict(zip(Key,Value)) 】映射列表(元组),Key -> Value 当元素数不一致,按少的进行。
            • d=dict(K=V)】 K 和 V都是标识符,找不到K自动创建。
        • 操作函数
          • 取值:【d.get(_key, _value)】 返回d中_key对应的value,如果_key不存在,返回_value
            • _value缺省,_key不存在返回None
          • 删除【d.pop(key)】
          • 取值域:返回一元组 【d.values()】
          • 取映射对:返回二元组 【d.items()】
            • 组中每个元素是(key ,value)
          • etc.
        • 操作符
          • d[key]=value 更改(或初次添加)key的值
          • _key in d 返回布尔类型,_key在d的定义域返回1
        • 对比双list:查找快,空间占用大
    • 类型判断函数:isinstance( object, classinfo)
      • object是变量,classinfo是类型名,相同返回1
      • 基本类型:
        • int float bool complex
        • str
        • list tuple
        • set dict
  • 条件
    • if ( ) :
      • 注意冒号
      • 语句块不需要大括号,而是通过缩进控制
    • elif():
      • 注意冒号
      • 表示else if (): 简写的作用是减少缩进
      • 可以有多个
    • else 相当于switch的default 。
  • 循环
    • 【 for x in list/tuple:】 创建变量x,按顺序遍历list/tuple中的每个元素一次,执行语句块
      • 注意冒号
      • 类似c++ for(x:{1,2,5,8,3})类型的循环
      • 列生成函数:range(n) 返回一个列 0,1,.... ,n-1
        • for(int i=0;i<n;++i){ 平替成:for i in range(n) :
    • 【while () :】同c while
    • 支持break和continue
  • 函数
    • 定义
      • 【def fun ( 形参表) : 】缩进块里写函数体。
      • 不限返回类型
    • 参数检查:
      • pass
    • 空函数体:【pass】
      • 作为占位符,避免报错。c的什么都不做函数有【;】表示空语句。
    • 各类参数
      • 位置参数:同c
      • 默认参数:同c++,第一个默认值后都需默认值
      • 可变参数:【def fun( * args):】
        • 优点:传入元素数未知
        • 本质:构造元组
          • 【def f ( *args ):】 构造一个元组args 其元素是传入的元素。
        • 向可变参数函数传入一个组:调用时:【 f( *list)】实参list前加*。
          • 此用法可适用给各种函数传参 eg >>>det test(x , y) ... pass >>>lis[1,2] >>>test(*lis)
      • 关键字参数:【def fun (**kw)】//kw是关键字缩写
        • 本质:构造字典
        • 调用方法:
          • fun(city="beijing" , password=123456)
          • 必须提供变量的名字
        • 优点:提供不同类的参数传入
        • 可变和关键字异同:
          • 同:提供方便 传入0到无穷多的参数
          • 异:
            • 可变->元组 同类参数,没有名字 例如求和函数
            • 关键字->字典 有名字的不同类参数 例如学生信息登记函数
        • 默认值:pass
      • 命名关键字参数
        • 优点:忽略传入参数的顺序
        • 实现方法:提供传入参数的名字
          • fun("Tom",24, city="Beijing" , password=123)
            • 其中tom和24是位置参数,但是city password两个参数是命名关键字参数,可以顺序互换
        • 歧义:位置参数or关键字参数?
          • fun("tom", 24 ,city ,password)中,没有区分哪个是关键字哪个是位置
          • 解决:fun(name, year , *,city ,password) 分隔记号* 之后的都是位置参数
      • 参数组合顺序:必选,默认,关键字,命名关键字
        • 用tuple和dict调用:fun(*args,**kw)//前面元组args中是没名字的参数,后面字典kw中是有名字的参数
    • 高阶函数:
      • map/reduce :映射/归并in
        • map
          • 映射函数map(fun , Iterable)
          • Iterable是定义域;fun是映射关系;返回值域,性质为同类Iterable
        • reduce
          • 简化归并 reduce(fun , Iterable )
          • fun是二元运算函数,两个自变量性质一致,返回值和自变量性质一致
          • 功能:用fun将Iterable的前两个元素归并成一个,得到新列。再归并新列的前两个元素,反复操作,reduce返回单个元素。
        • 模块:functools
      • filter :筛选
        • filter( fun, Iterable)
        • fun返回bool。顺次用fun处理Iterable的元素,0扔掉1保留,生成新Iterable。
      • sorted :排序
        • sorted( Iterable , * , cmp , key , reverse)
        • 后三是可选的命名关键字参数
        • cmp是比较函数
          • 传入两个组元素,返回值:正前者大 负后者大 零一样大。描述组元素序关系
        • key是值函数,传入一个组元素 返回可比较值。类似cmp,将组元素抽象为可比较的值。
        • reverse 是布尔值,缺省为零,升序。为1则降序。
    • 返回函数
      • 函数返回值可以是函数
      • 闭包(closure)
        • 返回函数的函数
        • 形式特点:分层传参
        • 本质:通过外层函数参数生成不同的函数
          • eg1
            • 本例子外层函数可以生成不同的直线函数 line(x)
          • eg2
            • 不用闭包
              • print出来333
            • 用闭包
              • 出来123
        • 只有外层函数有变量,是假的闭包
          • 输出999
          • f的状态可变,取决于调用f时i的状态
          • ??
        • 优点:
          • 提高复用
            • eg1不管生成几个一次函数,都可用
          • 保存函数运行环境
            • 本质上是生成的函数可以有不同状态,对应于传入不同的参数
              • eg2可固定循环变量i的值
    • 匿名函数【 lambda arg : 表达式】
      • 没有名字
      • 表达式的值就是返回值
      • 应用例子:
      • 仅调用一次的函数不需要名字,它只需要是个代码块,但是要把代码块的性质转为函数,以供传入其他现成函数。
    • 装饰器(decorator)
      • 修饰器是一个函数
      • 作用
        • 不改变被修饰函数本身的情况下实现附加功能(如打印日志),所以修饰器要以被修饰函数作为参数(之一)
      • 修饰的本质
        • 把原函数名重定向到另一个函数。后者模拟了原函数的功能同时附加了额外的功能。
        • 最终func被模拟成了simulation函数,外层嵌套都是分层传参需求的结果。
        • 而decorator()(func)中 decorator()的性质是函数,所以才可以加(func)参数。加入func参数后返回模拟函数,用以接受func真实的参数
      • 定义
        • 一般的
        • 为了使simulation的签名与func相同,需要将simulation修饰。 40行是内建的签名仿造函数,表示将simulation的签名仿成func
          • 内部类似 simulation.__name__=func.__name__
      • 调用方法
        • 函数定义前@_name_of_decorator(*args , **kw) (传的是修饰器需要的参数,不包含被修饰函数)
          • @_name_of_decorator(*args , **kw)是 func=_name_of_decorator(*args , **kw)(func)的语法糖
    • 偏函数(partial function) 【 fun2=functools.partial( fun , 指定的参数)】
      • 是一个函数
      • 确定原函数某些参数的默认值,返回新函数
      • eg. int是字符转整数函数,base是将字符视为数的基
  • 高级特性
    • 切片操作符【 L [ begin: end: step]】
      • L:一个list/tuple //字符串亦可看成list
      • 返回一个list/tuple 内容为 以L[begin]开始,每step中取一个 ,直到L[end] 结束且左闭右开
      • 三个参支持负
      • 缺省:begin=0 end=end step=1
        • eg
          • L[:3] 取前三个元素L0、1、2
          • L[-3:] 取倒数三个元素L-3、-2、-1
          • L[:] 不动抄下来
    • 迭代(Iteration)【for ___ in ___】
      • 一元组: 同for循环
        • 一元组下标生成:enumerate(L)
          • for i , value in enumerate( L):
      • 二元组:for x, y ,z in [(1,2,9),(3,4,9),(5,6,7)]:
      • 字典:for id in d:
        • 默认迭代对象是字典的key定义域,id是任意标识符
        • 迭代值域:for id in d.value
      • 字符串: for id in str:
      • 可迭代对象判断:
        • collections模块的 Iterable类型:
    • 列表生成式 【 [ f(x) for x in __ ] 】
      • 相当于map;但效率上map快
      • 用于生成列表,不能生成元组。
      • 【L=[f(x) for x in B] 】迭代B迭代指标为x,生成f(x)为元素的列表。
      • 附条件生成
        • 【 f (x) for x in B if (is(x)) 】 is(x) 为真时生成元素
      • 多层循环
        • eg:
    • 生成器(generator)
      • 生成器是一个对象 ,类似于链表,保存所生成“列表”的某个值
      • 可迭代
      • 本身不能循环,只是可多次yield。迭代时获得yield丢出的值。所以生成器要循环的话必须内置循环。
      • 生成方式:
        • 【 ( f(x) for __ in __ ) 】将列表生成式的方括号改成圆括号
        • 函数:关键字 yield
          • 本质
            • 生成器的本质是按顺序生成一个列表,而且不需同时保存整个列表(迭代访问每次只访问一个,每个只访问一次)
            • 所以某个函数如果自变量是一个整数,返回值可以是列表元素,那么该函数就可以作为一个生成器
          • 实现:将函数返回的return改成yield
            • eg:生成斐波那契的生成器
            • 生成器函数的返回值:pass
          • 调用:g=f()
            • g是生成器
            • f不写参数
      • 访问
        • 用迭代访问生成器 那么其功能等同于列表
        • x=next(g) x是列表元素,每再调用一次x变为下一个元素
      • g.send(x)
        • 生成器是自带的协程工具。它可以在yield处暂停,然后在其他地方的send()处开始切回生成器
        • 所以生成器是等别人的那个函数,死循环,每次consume;而另一个含send的函数是带参的循环体,循环product
        • 两函数的连接是,generator作为参数传入product并在后者内初始化和关闭。
        • generator更像一个“挂件”,负责封装一类功能。而product承担逻辑功能。
        • 如果product不需要改generator的状态,就 yield from取得下一个yield的输出值
        • 将x作为yield的返回值 并且从yield处切入g的内部开始运行。
        • 用g.send(x)初始化生成器时,x必须是None
    • 迭代器(iterator)
      • 迭代器与可迭代的非迭代器对象:
        • 消极/积极
          • 前者消极,是一个数据流。只能被next()调用,仅当需要下一个元素时才产生它
          • 后者积极,储存了一组元素的全部,可以随机访问
        • 迭代操作:
          • 迭代本质是对迭代器的操作,后者在迭代时被隐式转化为迭代器
        • 转化为迭代器:iter() 函数
  • 模块
    • 装有一些函数的.py文件
    • 模块可以避免函数名字冲突
      • 包是一个目录
      • 用以处理同名模块
      • 与普通目录的区别:该目录下要有一个__init__.py文件
        • __init__.py下可以有代码也可以无,它本身也可以是一个模块,模块名是文件名
    • 模块的使用 【import xxx】
      • 导入模块后,会创建名为xxx的变量指向模块,借此访问模块的全部内容(包括函数和变量)
  • 对象编程
    • 名词们
      • 类:抽象模板
      • 实例:具体的一段数据,类的具体化
      • 属性:类内的某个变量
      • 方法:类通用的操作函数
    • 创建类【 class 类名 (继承类) 】
      • 无继承类就继承object 这是所有类都最终继承的
    • 操作类
      • 构造函数
        • __init__(self, *arg ,* kw )
        • self必须有
        • self是实例本身,所以构造要绑属性时:【self. xxx=xxx】
    • 属性
      • 实例的属性除了类内自定的,还可以手工绑定 方式同属性 eg x.a
      • 访问限制
        • 双下划线【__】开头的属性可以避免外部变量访问,基本等同private
          • 实现机制是解释器给他们改名字,所以仍然可以通过改后的名字访问。全凭自觉
        • 形如【__xx__】的属性是特殊变量,可以访问。
    • 继承和多态
      • 继承会获得父类的全部方法和属性
      • 创建和父类同名的方法会覆盖。这种同名不同功的现象叫多态
    • 鸭子法则:pass
    • 获取对象信息
      • 类型判断
        • 【type(x)】返回变量x的类型
        • 【isinstance(x,type)】返回布尔,如果x是type或其子类,返回1
      • 获取属性和方法:【dir(实例或类名)】
        • 返回一个list 包含该实例所属类型的所有实例和方法
    • 动态绑定
      • 动态语言可以给已有的实例或类绑定新的属性或者方法
  • 高级对象
    • 绑定限制 __slots__
      • 这是一个类内定义的特殊属性。
      • 这是一个组,元素为字符串。
      • 组内的字符串是该类允许绑定的属性or方法名
      • 子类不继承slot但是如过子类也有__slots__属性,那么子类允许的名字为自己的和父类的slots
    • 构造函数属性化 @property
      • 1.只读: _name是要属性化的属性名
        • @property
        • def _name(self) :
        • return self._name
      • 2.构造函数属性化: @name.setter
        • @_name.setter
        • def _name(self , value) :
        • 这个函数就相当于构造函数,可以进行参数检查等.
      • @_name.xxx xxx还可是deleter
    • 多重继承 class c (f1,f1,....)
      • c可以继承多个父类的方法和显示属性
      • __init __会继承第一个父类
    • 特殊方法定制
      • 所有的类都有一些内置的方法, 一些被其他函数或语法所调用. 这些方法都能定制化
      • print实例: __str__()
        • 这是一个方法,返回字符串
      • 迭代性质: __iter__(self)__next__(self)
        • 期待一个Iterable时 可迭代对象理应有一个属性 ,是迭代的一个元素 , 然后用next()方法获得下一项.
        • iter返回自己,就是那个有可迭代方法的instance
        • next() 返回下一个元素并且要有结束判断if xxx : ...raise StopIteration()
        • eg .
        • 迭代副作用: pass
      • 函数式调用: __call__(self,*args,**kw)
        • 增加了该方法,可以直接函数式的调用实例x为: x(*args,**kw)
    • 元类 mateclass
      • 类是一种对象,创建类会在后台创建一个对象。元类生成一种类就像修饰器生成一个函数
      • 创建类 type(str_name, tuple, dict)
        • 返回值是类
        • str_name 是类的名字,是个字符串
        • tuple是父类的元组(多重继承,所以可能有多个)
        • dict是绑定的方法 key是创建类的方法名(性质为str),val是要绑上去的函数
  • 错误、调试、测试
    • 错误处理
      • try... except...(except...)else...finally】语句
        • try:当语句块可能出现错误时,将其放入try语句块。
        • 【except 错误类型 as e :】错误类型是从可选项里挑选的;as e指当有错误时,固定写法;冒号后是该类错误的处理方法
      • 错误抛出
        • 由于错误是一种类,所以可以选好继承关系后自定义。
  • IO编程
    • 文件读写
      • 打开文件【open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
        • w写 r读 a追加 +写和读 / b二进制
      • 关闭文件 file object 的方法。 eg >>>f=open("test.txt") >>>f.close()
      • 错误处理 :with open() as f
        • 打开文件失败要报错 try : f=open() finally : if : f f.close()
        • 语法糖:with open() as f 省去了f.c;ose() 以及try finally等步骤
    • StringIO
    • 系统文件和路径操作: os module
      • 文件和目录操作
        • 返回路径: 绝对 os.path.abspath('.')
          • 点是当前目录
        • 列出路径os.listdir(path) 返回list of str
        • 删除 : 路径: os.mkdir(path) 文件 :os.remove(path_of_file)
        • 重命名 os.rename(path_src,path_dst)
          • 文件和路径均可
        • 文件|路径拼接&拆分
          • 拼接 os.path.join(path,paths)
          • 拆分 os.path.split(path) 返回list [0]是head [1]是tail
        • 获取扩展名 os.path.splitext(path) 返回list [0]是前段 [1]是扩展名(含点 eg '.py')
        • 类型判断 os.path.isdir(path) os.path.isfile(path)
        • 文件筛选的例子:
          • [x for x in os.listdir('.') if os.path.isdir(x)] 筛选当前目录下的目录,返回一个list of dir
          • [x for x in os.listdir('.') if os.path.splitext(x)[1] & os.path.isfile(x) ] 筛选当前目录下的.py文件 返回list
      • 环境变量 os.environ
    • 序列化 pass 格式互通 JSON
  • 正则表达式
    • 功能:字符串格式化判断
    • 正则表达式也是字符串 是一种用字符描述字符的方法
    • 语法:子表达式(及其修饰)的连缀
    • 子表达式
      • 单字符 eg a 注意\转义: * . ? + $ ^ [ ] ( ) { } | \ /
      • 范围 [ ] eg[a-z0-9\?:\!] 表示小写字母 数字 ? : ! 中的一个。性质上是单字符
      • 通配字符:
        • \d 数字 =0-9
        • \w 数字字母下划线 =[0-9a-zA-Z_]
        • . 任意字符
        • \s 任意空字符 空格制表符换行分页等
    • 修饰
      • 数量限定
        • 说明了被匹配
        • 位置:修饰在表达式的后面 eg \d+
        • *
        • +
        • ?
        • {n}表示被修饰子表达式重复n次,n非负整
        • {n,} 重复至少n次
        • {n,m}重复至少n至多m次
      • 位置限定
        • 定位符不是字符,而是说明了要匹配字符的位置
        • ^ 位置在被修饰的前方,表示行首
        • $在尾部,表示行位
        • \b单词边界定位 位置:在表达式前表示匹配单词的开头;在表达式后表示匹配词尾
          • eg \bCha 匹配词头为Cha的单词
          • eg ter\b匹配词尾为ter的单词 例如Chapter 但是不匹配determine
        • \B 非边界定位 表示被修饰表达式不在边界处
    • 分界和连接
      • 表达式直接连缀,禁止写空格 因为空格是一个字符
      • 分界:() 括在一起视为一个子表达式
      • 连接: 或运算 | 二元运算符 对象是表达式,结果视为一个表达式,是二者之一
  • 内建模块
  • 异步IO
    • asyncio
      • 协程对象 async def func():它的返回值是协程对象。获取返回时func的调用不会立刻执行函数体,直接返回协程对象
        • async函数内 只可调用异步函数。调用时要await eg. await asyncio.sleep(2)
      • 创建loop对象 loop = asyncio.get_event_loop() 无参
      • 创建任务对象:
        • task : task = loop.creat_task(co) 是loop的方法
        • future: task = asyncio.ensure_future(co) 是不基于loop的方法
      • 运行循环:
        • loop.run_until_complete(task) 是loop的方法,传入task
        • loop.run_until_complete( asyncio.wait(tast_list) ) 传入task_list然后执行
      • 绑定回调
        • task.add_done_callback(func) 绑定回调函数。func是回调函数,参数为task任务对象。task.result()是task的方法,返回task内封装的协程函数的返回值
    • aiohttp
      • 注意await!各种函数都await。实在不行看warning
      • async with aiohttp.ClientSession() as session :异步的取得session对象
      • async with await session.get(url) as response :